Transformation to Dynamic Single Assignment Using a Simple Data Flow Analysis

This paper presents a novel method to construct a dynamic single assignment (DSA) form of array-intensive, pointer-free C programs (or in any other procedural language). A program in DSA form does not perform any destructive update of scalars and array elements, i.e., each element is written at most once. As DSA makes the dependencies between variable references explicit, it facilitates complex analyses and optimizations of programs. This makes it a preferred intermediate form for a number of compiler techniques of growing importance: parallelization, systolic array design, programming heterogeneous architectures, memory optimization, and verification of source code transformations. Existing transformations into DSA perform a complex data flow analysis that is exponential in the program size and that only accepts input programs where all loop bounds, array indexation and conditionals are (possibly piecewise) affine expressions in the loop iterators. Our method removes irregularities from the data flow by adding copy assignments to the program, and then it can use simple data flow analyses. The contributions of this paper are threefold. The DSA transformation presented scales very well with growing program sizes. It is quadratic in the program size –though our experiments indicate that it tends towards linearity– and is polynomial in the loop nest depth, while other existing methods have exponential complexity. Our DSA transformation overcomes a number of important limitations of existing methods; it allows any expression for loop bounds, indexation and conditionals, as long as constant bounds can be found for loop iterators. We have implemented the method and it is being used in the context of memory optimization and verification of those optimizations.